package com.ciwong.epaper.modules.me.util;

import android.text.TextUtils;

import com.ciwong.epaper.modules.me.bean.Clazz;
import com.ciwong.libs.utils.StringUtils;

import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.Iterator;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 班级工具
 *
 * @author sugy
 * @version ciwong v.1.0 2015/9/17 11:58
 * @since ciwong v.1.0
 */
public class MeUtil
{
    /**
     * 过滤班级列表(只显示普通班级和自定义班级)
     * 
     * @param clazzList
     */
    public static void filterClass(List<Clazz> clazzList)
    {
        if (clazzList == null || clazzList.isEmpty())
        {
            return;
        }
        for (Iterator<Clazz> iterator = clazzList.iterator(); iterator
                .hasNext();)
        {
            Clazz clazz = iterator.next();
            if (clazz != null && clazz.getClassType() != 1
                    && clazz.getClassType() != 6)
            {
                iterator.remove();
            }
        }
    }


    /**
     * 保留小数点
     *
     * @param value
     *            输入值
     * @param point
     *            保留的小数点
     * @return
     */
    public static String radixPoint(double value, int point)
    {
        String str = "";
        for (int i = 0; i < point; i++)
        {
            if (i == 0)
            {
                str += ".";
            }
            str += "0";
        }
        str = "##0" + str;
        DecimalFormat fnum = new DecimalFormat(str);
        String dd = fnum.format(value);
        return dd;
    }

    /**
     * 中文判断
     *
     * @param name
     *
     * @return true为中文
     */
    public static boolean validateUserName(String name)
    {
        Pattern pattern = Pattern.compile("^[\u4E00-\u9FA5]{2,10}$");
        return pattern.matcher(name).find();
    }
    /**
     * 判断是否是手机号码
     * @param mobiles
     * @return
     */
    public static boolean isMobileNum(String mobiles) {

        if (TextUtils.isEmpty(mobiles)) {
            return false;
        }


//        Pattern p = Pattern.compile("^((13[0-9])|(14[5,7])|(15[^4,\\D])|(18[0,1,2,3,4,5-9])|(17[0,1,6，7,8]))\\d{8}$");
        Pattern p = Pattern.compile("^\\d{11}$");

        Matcher m = p.matcher(mobiles);

        return m.matches();
    }
    /**
     * 判断是否为6位纯数字验证码
     * @param verify_code
     * @return
     */
    public static boolean isVerify_code_six(String verify_code) {

        if (TextUtils.isEmpty(verify_code)) {
            return false;
        }

        Pattern p = Pattern.compile("^\\d{6}$");

        Matcher m = p.matcher(verify_code);

        return m.matches();
    }




    /**
     * 验证密码
     *
     * @param pwd
     *            密码字符串
     * @return 验证是否通过
     */
    public static boolean validatePassword(String pwd)
    {
        if (pwd == null || "".equals(pwd)) {
            return false;
        }
        Pattern pattern = Pattern
                .compile("(?=.*[0-9])(?=.*[A-Z])(?=.*[a-z]).{8,30}");
        return pattern.matcher(pwd).matches();
    }
    /**
     * 验证密码 可以为纯数字　和字母数字混合
     *
     * @param pwd
     *            密码字符串
     * @return 验证是否通过
     */
    public static boolean validatePassword2(String pwd)
    {
        Pattern pattern = Pattern
                .compile("^[0-9A-Za-z]{6,16}$");
        return pattern.matcher(pwd).matches();
    }


    /**
     * 转化,当是整数时不显示小数位
     *
     * @param d
     * @return
     */
    private static String doubleTrans(float d)
    {
        if (Math.round(d) - d == 0)
        {
            return String.valueOf((long) d);
        }
        return String.valueOf(d);
    }

    /**
     * 格式化分数，四舍五入，保留2位小数，当是整数时不显示小数位
     *
     * @param score
     * @return
     */
    public static String formatScore(double score)
    {
        return doubleTrans(getScale(score));
    }

    /**
     * 四舍五入
     *
     * @param score
     * @return
     */
    public static float getScale(double score)
    {
        if (score == 0)
        {
            return 0;
        }
        BigDecimal bigDecimal = new BigDecimal(score);
        return bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).floatValue();
    }
    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入。
     * @param v1 被除数
     * @param v2 除数
     * @param scale 表示表示需要精确到小数点以后几位。
     * @return 两个参数的商
     */
    public static double divide(double v1, double v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }
}
